home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / daten / ispell / interfaces / willy-ttx / quicksort-source / quicksort.c < prev   
Encoding:
C/C++ Source or Header  |  1992-09-29  |  8.4 KB  |  336 lines
  1. /* A test program to demonstrate the direct variable interface to ARexx.
  2.  * Opens a public port called "VarTest" and then waits for REXX messages.
  3.  * The port stays open until a "CLOSE" command is received.
  4.  * Usage:  run vartest
  5.  * Then send commands from within ARexx by "address 'VarTest' command"
  6.  *
  7.  *    This version for Manx. WGL
  8.  *    This version for SAS
  9.  */
  10.  
  11. /*
  12. *   Standard includes for SAS C.
  13. */
  14. #include <exec/types.h>
  15. #include <exec/exec.h>
  16. #include <intuition/intuitionbase.h>
  17. #include <intuition/gadgetclass.h>
  18. #include <libraries/gadtools.h>
  19. #include <graphics/gfxbase.h>
  20. #include <graphics/text.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <ctype.h>
  25. #include <proto/rexxsys.h>
  26. #include <proto/all.h>
  27.  
  28. /*
  29. *   Prototypes for functions defined in RexxVars.o
  30. */
  31. long __stdargs SetRexxVar(struct RexxMsg *, unsigned char *, unsigned char *,
  32.                           long);
  33. long __stdargs GetRexxVar(struct RexxMsg *, unsigned char *, STRPTR *, long);
  34.  
  35. long __stdargs CheckRexxMsg(struct RexxMsg *);
  36.  
  37. static long Sort(struct List *);
  38. static void ReturnMsg(struct RexxMsg *, long, long);
  39. static struct List *AddList(struct List *, char *, long);
  40. static struct List *NukeList(struct List *);
  41. static struct List *GetRexxList(struct RexxMsg *, long);
  42. static struct List *PutRexxList(struct RexxMsg *, struct List *);
  43.  
  44. struct Node *ListRequest(struct Screen *, struct List *, long, long, long, long);
  45.  
  46. struct RexxLib *RexxSysBase         = NULL;
  47. struct IntuitionBase *IntuitionBase = NULL;
  48. struct GfxBase *GfxBase             = NULL;
  49. struct Library *GadToolsBase        = NULL;
  50.  
  51. #define DO_SORT 1
  52. #define NO_SORT 0
  53.  
  54. void main(int argc, char **argv)
  55. {
  56.    struct MsgPort *MyPort = NULL;
  57.    struct RexxMsg *rmptr;
  58.    long           quitflag = 0, sortflag;
  59.    long           res1, res2, x = 0, y = 0, w = 0, h = 0, n;
  60.    struct List    *list = NULL;
  61.    struct Node    *result;
  62.    char           *screenname = NULL, *flags = NULL, *ptr;
  63.    struct Screen  *screen = NULL;
  64.  
  65.    RexxSysBase = (struct RexxLib *) OpenLibrary("rexxsyslib.library",0);
  66.    if (RexxSysBase == 0L) goto cleanup;
  67.  
  68.    IntuitionBase = (struct RexxLib *) OpenLibrary("intuition.library",0);
  69.    if (IntuitionBase == 0L) goto cleanup;
  70.  
  71.    GfxBase = (struct RexxLib *) OpenLibrary("graphics.library",0);
  72.    if (GfxBase == 0L) goto cleanup;
  73.  
  74.    GadToolsBase = (struct RexxLib *) OpenLibrary("gadtools.library",0);
  75.    if (GadToolsBase == 0L) goto cleanup;
  76.  
  77.    MyPort = CreatePort("QuickSortPort", NULL);
  78.    if (MyPort == NULL) goto cleanup;
  79.  
  80.    while (quitflag == 0) {
  81.       Wait(1L << MyPort->mp_SigBit);
  82.  
  83.       rmptr = (struct RexxMsg *) GetMsg(MyPort);
  84.  
  85.       res1 = res2 = 0L;
  86.       if (CheckRexxMsg(rmptr)) {
  87.          if (stricmp(rmptr->rm_Args[0], "QSORT") == 0) {
  88.             if ((rmptr->rm_Action & 0xFF) == 3) {
  89. /*
  90. *   Get the strings array using insertion sort
  91. */
  92.                list = GetRexxList(rmptr, DO_SORT);
  93. /*
  94. *   Now put them back.
  95. */
  96.                if (list) list = PutRexxList(rmptr, list);
  97.  
  98.                if (list == NULL) {
  99.                   res1 = 10L;
  100.                   res2 = 12L;
  101.                }
  102.  
  103.                list = NukeList(list);
  104.             }
  105.             else {
  106.                res1 = 10;
  107.                res2 = 17;
  108.             }
  109.          }
  110.          else if (stricmp(rmptr->rm_Args[0], "LISTREQUEST") == 0) {
  111.             if ((n = (rmptr->rm_Action & 0xFF)) < 4) {
  112.                res1 = 10;
  113.                res2 = 17;
  114.             }
  115.             else {
  116.                if (n >= 5)  x = atol(rmptr->rm_Args[5]);
  117.                if (n >= 6)  y = atol(rmptr->rm_Args[6]);
  118.                if (n >= 7)  w = atol(rmptr->rm_Args[7]);
  119.                if (n >= 8)  h = atol(rmptr->rm_Args[8]);
  120.                if (n >= 9)  screenname = rmptr->rm_Args[9];
  121.                if (n >= 10) flags      = rmptr->rm_Args[10];
  122.  
  123.                sortflag = NO_SORT;
  124.                if (flags && (stricmp(flags, "SORT") == 0)) sortflag = DO_SORT;
  125.  
  126.                list = GetRexxList(rmptr, sortflag);
  127.  
  128.                if (list) {
  129.                   if (screenname) screen = LockPubScreen(screenname);
  130.  
  131.                   result = ListRequest(screen, list, x, y, w, h);
  132.  
  133.                   if (screen) UnlockPubScreen(NULL, screen);
  134.  
  135.                   if (result) ptr = result->ln_Name;
  136.                   else        ptr = "";
  137.  
  138.                   SetRexxVar(rmptr, rmptr->rm_Args[4], ptr, strlen(ptr));
  139.  
  140.                   list = NukeList(list);
  141.                }
  142.                else {
  143.                   res1 = 10L;
  144.                   res2 = 12L;
  145.                }
  146.             }
  147.          }
  148. /*
  149. *   See whether it's the close command
  150. */
  151.          else if (strcmp(rmptr->rm_Args[0], "CLOSE") == 0) {
  152.             quitflag = 1;
  153.          }
  154.          else if (strcmp(rmptr->rm_Args[0], "QUIT") == 0) {
  155.             quitflag = 1;
  156.          }
  157.          else {
  158.             res1 = 5;
  159.             res2 = 1;
  160.          }
  161.       }
  162.       else {
  163.          res1 = 10;
  164.          res2 = 10;
  165.       }
  166. /*
  167. *   If we get here, we handled the command, but didn't return yet.
  168. */
  169.       ReturnMsg(rmptr, res1, res2);
  170.    }
  171.  
  172. cleanup:
  173.    if (MyPort)        DeletePort(MyPort);
  174.    if (RexxSysBase)   CloseLibrary(RexxSysBase);
  175.    if (GadToolsBase)  CloseLibrary(GadToolsBase);
  176.    if (GfxBase)       CloseLibrary(GfxBase);
  177.    if (IntuitionBase) CloseLibrary(IntuitionBase);
  178.  
  179.    exit(0);
  180. }
  181.  
  182.  
  183. static struct List *GetRexxList(rmptr, sortflag)
  184. struct RexxMsg *rmptr;
  185. long sortflag;
  186. {
  187.    long left, right, i, error;
  188.    char buffer[256];
  189.    STRPTR value;
  190.    struct List *list = NULL;
  191. /*
  192. *   Get left and right bounds of string array to be sorted
  193. */
  194.    left  = atoi(rmptr->rm_Args[1]);
  195.    right = atoi(rmptr->rm_Args[2]);
  196. /*
  197. *   Copy RexxVariable array into strings
  198. */
  199.    for (i = left; i <= right; i++) {
  200. /*
  201. *   Put name of stem in buffer
  202. */
  203.       sprintf(buffer, "%s.%d", rmptr->rm_Args[3], i);
  204. /*
  205. *   Now get the string from the program
  206. */
  207.       error = GetRexxVar(rmptr, buffer, &value, 256);
  208.       if (error) {
  209.          list = NukeList(list);
  210.          break;
  211.       }
  212.       list = AddList(list, (char *) value, sortflag);
  213.    }
  214.    return(list);
  215. }
  216.  
  217.  
  218. static struct List *PutRexxList(rmptr, list)
  219. struct RexxMsg *rmptr;
  220. struct List *list;
  221. {
  222.    long left, right, i, error;
  223.    char buffer[256], *ptr;
  224.    struct Node *n;
  225. /*
  226. *   Get left and right bounds of string array to be sorted
  227. */
  228.    left  = atoi(rmptr->rm_Args[1]);
  229.    right = atoi(rmptr->rm_Args[2]);
  230. /*
  231. *   Put sort ed array back in old stem variable
  232. */
  233.    for (i = left, n = list->lh_Head; i <= right; i++, n = n->ln_Succ) {
  234. /*
  235. *   Put name of stem in buffer
  236. */
  237.       sprintf(buffer, "%s.%d", rmptr->rm_Args[3], i);
  238.       ptr = n->ln_Name;
  239. /*
  240. *   Now get the string from the program
  241. */
  242.       error = SetRexxVar(rmptr, buffer, ptr, strlen(ptr));
  243.       if (error) {
  244.          list = NukeList(list);
  245.          break;
  246.       }
  247.    }
  248.    return(list);
  249. }
  250.  
  251.  
  252. static void ReturnMsg(rmptr, res1, res2)
  253. struct RexxMsg *rmptr;
  254. long res1, res2;
  255. {
  256.    rmptr->rm_Result1 = res1;
  257.    rmptr->rm_Result2 = res2;
  258.    ReplyMsg(rmptr);
  259.    return;
  260. }
  261.  
  262. /**
  263. *
  264. *   Some list utility functions.
  265. *   AddList adds a string to an Exec list. If the list doesn't exist
  266. *   yet, it is first created. If sortflag is true, the list is sorted
  267. *   using insertion sort.
  268. *   NukeList deletes an entire list created by AddList.
  269. *
  270. **/
  271. #define LSIZE ((long) sizeof(struct List))
  272. #define NSIZE ((long) sizeof(struct Node))
  273.  
  274. static struct List *AddList(list, s, sortflag)
  275. struct List *list;
  276. char *s;
  277. long sortflag;
  278. {
  279.    struct Node *n, *nt;
  280.    char *ptr;
  281.  
  282.    if (list == NULL) {
  283.       list = AllocMem(LSIZE, MEMF_CLEAR);
  284.       if (list == NULL) return(NULL);
  285.       NewList(list);
  286.    }
  287.  
  288.    if (s) {
  289.       n = AllocMem(NSIZE, MEMF_CLEAR);
  290.       if (n == NULL) return(NukeList(list));
  291.  
  292.       ptr = AllocMem(strlen(s) + 1, 0L);
  293.       if (ptr == NULL) return(NukeList(list));
  294.  
  295.       strcpy(ptr, s);
  296.       n->ln_Name = ptr;
  297.  
  298.       if (sortflag) {
  299.          nt = list->lh_Head;
  300.          while (nt->ln_Succ) {
  301.             if (stricmp(nt->ln_Name, ptr) >= 0) break;
  302.             nt = nt->ln_Succ;
  303.          }
  304.          Insert(list, n, nt->ln_Pred);
  305.       }
  306.       else {
  307.          AddTail(list, n);
  308.       }
  309.    }
  310.  
  311.    return(list);
  312. }
  313.  
  314. static struct List *NukeList(list)
  315. struct List *list;
  316. {
  317.    struct Node *n, *nn;
  318.    char *ptr;
  319.  
  320.    if (list) {
  321.       if (list != (struct List *) list->lh_TailPred) {
  322.          n = list->lh_Head;
  323.          while (nn = n->ln_Succ) {
  324.             Remove(n);
  325.             if (ptr = n->ln_Name) FreeMem(ptr, strlen(ptr) + 1);
  326.             FreeMem(n, NSIZE);
  327.             n = nn;
  328.          }
  329.       }
  330.       FreeMem(list, LSIZE);
  331.    }
  332.    return(NULL);
  333. }
  334.  
  335.  
  336.